/* @(#)FmmNodeDictionary.java
** 
** Copyright (C) 2012 by Steven D. Stamps
**
**             Trademarks & Copyrights
** Flywheel Management Science(TM), Flywheel Management Model(TM),
** Flywheel Story Editor(TM) and FlywheelMS(TM) are exclusive trademarks
** of Steven D. Stamps and may only be used freely for the purpose of
** identifying the unforked version of this software.  Subsequent forks
** may not use these trademarks.  All other rights are reserved.
**
** DecKanGL (Decorated Kanban Glyph Language) and TribKn (Tribal Knowledge)
** are also exclusive trademarks of Steven D. Stamps.  These may be used
** freely within the unforked FlywheelMS application and documentation.
** All other rights are reserved.
**
** gConGUI (game Controller Graphical User Interface) is an exclusive
** trademark of Steven D. Stamps.  This trademark may be used freely
** within the unforked FlywheelMS application and documentation.
** All other rights are reserved.
**
** Trademark information is available at
** <http://www.flywheelms.com/trademarks>
**
** Flywheel Management Science(TM) is a copyrighted body of management
** metaphors, governance processes, and leadership techniques that is
** owned by Steven D. Stamps.  These copyrighted materials may be freely
** used, without alteration, by the community (users and developers)
** surrounding this GPL3-licensed software.  Additional copyright
** information is available at <http://www.flywheelms.org/copyrights>
**
**              GPL3 Software License
** This program is free software: you can use it, redistribute it and/or
** modify it under the terms of the GNU General Public License, version 3,
** as published by the Free Software Foundation. This program is distributed
** in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
** even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
** PURPOSE.  See the GNU General Public License for more details. You should
** have received a copy of the GNU General Public License, in a file named
** COPYING, along with this program.  If you cannot find your copy, see
** <http://www.gnu.org/licenses/gpl-3.0.html>.
*/

package com.flywheelms.library.fmm.node.impl.enumerator;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;

import android.graphics.drawable.Drawable;

import com.flywheelms.library.FmsLibraryApplication;
import com.flywheelms.library.R;
import com.flywheelms.library.fmm.deckangl.FmmDecKanGlDictionary;
import com.flywheelms.library.fmm.helper.FmmHelper;
import com.flywheelms.library.fmm.node.NodeId;
import com.flywheelms.library.fmm.node.impl.commitment.FlywheelCommitment;
import com.flywheelms.library.fmm.node.impl.commitment.ServiceDeliveryCommitment;
import com.flywheelms.library.fmm.node.impl.commitment.StrategicCommitment;
import com.flywheelms.library.fmm.node.impl.governable.Bookshelf;
import com.flywheelms.library.fmm.node.impl.governable.DiscussionTopic;
import com.flywheelms.library.fmm.node.impl.governable.FacilitationIssue;
import com.flywheelms.library.fmm.node.impl.governable.FiscalYear;
import com.flywheelms.library.fmm.node.impl.governable.FlywheelMilestone;
import com.flywheelms.library.fmm.node.impl.governable.FlywheelTeam;
import com.flywheelms.library.fmm.node.impl.governable.FmsOrganization;
import com.flywheelms.library.fmm.node.impl.governable.FunctionalTeam;
import com.flywheelms.library.fmm.node.impl.governable.Notebook;
import com.flywheelms.library.fmm.node.impl.governable.Portfolio;
import com.flywheelms.library.fmm.node.impl.governable.Project;
import com.flywheelms.library.fmm.node.impl.governable.ProjectAsset;
import com.flywheelms.library.fmm.node.impl.governable.ServiceOffering;
import com.flywheelms.library.fmm.node.impl.governable.ServiceOfferingSla;
import com.flywheelms.library.fmm.node.impl.governable.ServiceRequest;
import com.flywheelms.library.fmm.node.impl.governable.StrategicMilestone;
import com.flywheelms.library.fmm.node.impl.governable.StrategicTeam;
import com.flywheelms.library.fmm.node.impl.governable.WorkPackage;
import com.flywheelms.library.fmm.node.impl.governable.WorkPlan;
import com.flywheelms.library.fmm.node.impl.governable.WorkTask;
import com.flywheelms.library.fmm.node.impl.headline.CommunityMember;
import com.flywheelms.library.fmm.node.impl.link.BookshelfLinkToNotebook;
import com.flywheelms.library.fmm.node.impl.link.CommunityMemberFlywheelTeamGovernanceAuthority;
import com.flywheelms.library.fmm.node.impl.link.CommunityMemberOrganizationGovernanceAuthority;
import com.flywheelms.library.fmm.node.impl.link.DiscussionTopicLinkToNodeFragAuditBlock;
import com.flywheelms.library.fmm.node.impl.link.FacilitationIssueNodeTarget;
import com.flywheelms.library.fmm.node.impl.link.FlywheelTeamAnnualWorkTaskBudget;
import com.flywheelms.library.fmm.node.impl.link.FlywheelTeamCommunityMember;
import com.flywheelms.library.fmm.node.impl.link.FunctionalTeamCommunityMember;
import com.flywheelms.library.fmm.node.impl.link.NotebookLinkToDiscussionTopic;
import com.flywheelms.library.fmm.node.impl.link.OrganizationCommunityMember;
import com.flywheelms.library.fmm.node.impl.link.OrganizationGovernanceTarget;
import com.flywheelms.library.fmm.node.impl.link.OrganizationLockConfig;
import com.flywheelms.library.fmm.node.impl.link.PortfolioLinkToProject;
import com.flywheelms.library.fmm.node.impl.link.ProjectAssetLinkToWorkPackage;
import com.flywheelms.library.fmm.node.impl.link.ProjectLinkToProjectAsset;
import com.flywheelms.library.fmm.node.impl.link.ServiceRequestLinkToWorkTask;
import com.flywheelms.library.fmm.node.impl.link.StrategicTeamCommunityMember;
import com.flywheelms.library.fmm.node.impl.link.WorkPackageLinkToWorkTask;
import com.flywheelms.library.fmm.node.impl.link.WorkTaskAssignment;
import com.flywheelms.library.fmm.node.impl.nodefrag.NodeFragAuditBlock;
import com.flywheelms.library.fmm.node.impl.nodefrag.NodeFragGovernance;
import com.flywheelms.library.fmm.node.impl.supporting.ServiceRequestTriageLog;
import com.flywheelms.library.fmm.node.impl.supporting.TribKnQualityEnumeration;
import com.flywheelms.library.fmm.node.interfaces.FmmEnumNode;
import com.flywheelms.library.fmm.node.interfaces.horizontal.FmmNode;
import com.flywheelms.library.fmm.repository.FmmRepository;
import com.flywheelms.library.fmm.transaction.FmmNodeGlyphType;
import com.flywheelms.library.fse.model.FseDocument;
import com.flywheelms.library.fse.model.FseParagraph;

public enum FmmNodeDictionary implements FmmEnumNode {

	// DO NOT CHANGE NodeIdCode values !!!  
	// THIS IS PERSISTED DATA that is CRITICAL TO THE INTEGRITY OF THE MANAGEMENT MODEL !!!
    ASSIGNMENT_COMMITMENT_TYPE (
    		AssignmentCommitmentType.class,
    		"ACT",
    		R.string.fmm_node_definition__assignment_commitment_type__label_text,
    		R.drawable.commitment__none,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    BOOKSHELF (
    		Bookshelf.class,
    		"BKS",
    		R.string.fmm_node_definition__bookshelf__label_text,
    		R.drawable.fmm_noun__bookshelf__gray,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    BOOKSHELF_LINK_TO_NOTEBOOK (
    		BookshelfLinkToNotebook.class,
    		"BLN",
    		R.string.fmm_node_definition__bookshelf_link_to_notebook__label_text,
    		R.drawable.null_drawable,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    COMMUNITY_MEMBER (
    		CommunityMember.class,
    		"CMR",
    		R.string.fmm_node_definition__community_member__label_text,
    		R.drawable.fmm_noun__bookshelf__gray,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    COMMUNITY_MEMBER_FLYWHEEL_TEAM_GOVERNANCE_AUTHORITY (
    		CommunityMemberFlywheelTeamGovernanceAuthority.class,
    		"CFG",
    		R.string.fmm_node_definition__community_member_flywheel_team_governance_authority__label_text,
    		R.drawable.null_drawable,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    COMMUNITY_MEMBER_ORGANIZATION_GOVERNANCE_AUTHORITY (
    		CommunityMemberOrganizationGovernanceAuthority.class,
    		"COG",
    		R.string.fmm_node_definition__community_member_organization_governance_authority__label_text,
    		R.drawable.null_drawable,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    COMMUNITY_MEMBER_STATUS (
    		CommunityMemberStatus.class,
    		"CMS",
    		R.string.fmm_node_definition__community_member_status__label_text,
    		R.drawable.null_drawable,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    COMPLETABLE_WORK_STATUS (
    		CompletableWorkState.class,
    		"CWS",
    		R.string.fmm_node_definition__completable_work_status__label_text,
    		R.drawable.completable_work_status,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    COMPLETION_COMMITMENT_TYPE (
    		CompletionCommitmentType.class,
    		"CCT",
    		R.string.fmm_node_definition__completion_commitment_type__label_text,
    		R.drawable.commitment__none,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    DISCUSSION_TOPIC (
    		DiscussionTopic.class,
    		"DTC",
    		R.string.fmm_node_definition__discussion_topic__label_text,
    		R.drawable.fmm_noun__discussion_topic__gray,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    DISCUSSION_TOPIC_LINK_TO_NODE_FRAG_AUDIT_BLOCK	(
    		DiscussionTopicLinkToNodeFragAuditBlock.class,
    		"DTL",
    		R.string.fmm_node_definition__discussion_topic_link_to_node_frag_audit_block__label_text,
    		R.drawable.null_drawable,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    FACILITATION_ISSUE (
    		FacilitationIssue.class,
    		"FIU",
    		R.string.fmm_node_definition__facilitation_issue__label_text,
    		R.drawable.fmm_noun__facilitation_issue__gray,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    FACILITATION_ISSUE_LINK_TO_WORK_TASK (
    		FacilitationIssueNodeTarget.class,
    		"FLW",
    		R.string.fmm_node_definition__facilitation_issue_link_to_work_task__label_text,
    		R.drawable.null_drawable,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    FISCAL_YEAR (
    		FiscalYear.class,
    		"FYR",
    		R.string.fmm_node_definition__fiscal_year__label_text,
    		R.drawable.fmm_noun__fiscal_year__gray,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    FLYWHEEL_COMMITMENT (
    		FlywheelCommitment.class,
    		"TCT",
    		R.string.fmm_node_definition__flywheel_commitment__label_text,
    		R.drawable.commitment__none,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    FLYWHEEL_MILESTONE (
    		FlywheelMilestone.class,
    		"TMN",
    		R.string.fmm_node_definition__notebook__label_text,
    		R.drawable.fmm_noun__flywheel_milestone__gray,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    FLYWHEEL_TEAM (
    		FlywheelTeam.class,
    		"FTE",
    		R.string.fmm_node_definition__flywheel_team__label_text,
    		R.drawable.fmm_noun__flywheel_team,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    FLYWHEEL_TEAM_COMMUNITY_MEMBER (
    		FlywheelTeamCommunityMember.class,
    		"FTM",
    		R.string.fmm_node_definition__flywheel_team_community_member__label_text,
    		R.drawable.fmm_noun__community_member__on_leave,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    FLYWHEEL_TEAM_WORK_TASK_BUDGET (
    		FlywheelTeamAnnualWorkTaskBudget.class,
    		"FTB",
    		R.string.fmm_node_definition__flywheel_team_work_task_budget__label_text,
    		R.drawable.null_drawable,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    FSE_DOCUMENT (
    		FseDocument.class,
    		"FSD",
    		R.string.fmm_node_definition__fse_document__label_text,
    		R.drawable.fse_document,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    FSE_PARAGRAPH (
    		FseParagraph.class,
    		"FSP",
    		R.string.fmm_node_definition__fse_paragraph__label_text,
    		R.drawable.fse_paragraph,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    FUNCTIONAL_TEAM (
    		FunctionalTeam.class,
    		"UTE",
    		R.string.fmm_node_definition__functional_team__label_text,
    		R.drawable.fmm_noun__functional_team,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    FUNCTIONAL_TEAM_COMMUNITY_MEMBER (
    		FunctionalTeamCommunityMember.class,
    		"UTM",
    		R.string.fmm_node_definition__functional_team_community_member__label_text,
    		R.drawable.null_drawable,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    GOVERNANCE_PARTICIPATION_TYPE (
    		GovernanceParticipationType.class,
    		"GPT",
    		R.string.fmm_node_definition__governance_participation_type__label_text,
    		R.drawable.null_drawable,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    GOVERNANCE_ROLE (
    		GovernanceRole.class,
    		"GOR",
    		R.string.fmm_node_definition__governance_role__label_text,
    		R.drawable.fmm_noun__team_role,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    GOVERNANCE_TARGET (
    		GovernanceTarget.class,
    		"GOT",
    		R.string.fmm_node_definition__governance_target__label_text,
    		R.drawable.null_drawable,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    ISSUE_STATUS (
    		FacilitationIssueStatus.class,
    		"IST",
    		R.string.fmm_node_definition__issue_status__label_text,
    		R.drawable.null_drawable,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    LOCK_CONFIG (
    		LockConfig.class,
    		"LOC",
    		R.string.fmm_node_definition__lock_config__label_text,
    		R.drawable.null_drawable,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    LOCK_TYPE (
    		LockType.class,
    		"LOT",
    		R.string.fmm_node_definition__lock_type__label_text,
    		R.drawable.null_drawable,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    NODE_FRAG_AUDIT_BLOCK (
    		NodeFragAuditBlock.class,
    		"NFA",
    		R.string.fmm_node_definition__node_frag__audit_block__label_text,
    		R.drawable.audit_block,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    NODE_FRAG_GOVERNANCE (
    		NodeFragGovernance.class,
    		"NFG",
    		R.string.fmm_node_definition__node_frag__governance__label_text,
    		R.drawable.governance,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    NOTEBOOK (
    		Notebook.class,
    		"NBK",
    		R.string.fmm_node_definition__notebook__label_text,
    		R.drawable.fmm_noun__notebook__gray,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    NOTEBOOK_LINK_TO_FACILITATION_ISSUE (
    		NotebookLinkToDiscussionTopic.class,
    		"NLD",
    		R.string.fmm_node_definition__notebook_link_to_discussion_topic__label_text,
    		R.drawable.null_drawable,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    ORGANIZATION (
    		FmsOrganization.class,
    		"ORG",
    		R.string.fmm_node_definition__organization__label_text,
    		R.drawable.fmm_noun__organization,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    ORGANIZATION_COMMUNITY_MEMBER (
    		OrganizationCommunityMember.class,
    		"OCM",
    		R.string.fmm_node_definition__organization_community_member__label_text,
    		R.drawable.null_drawable,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    ORGANIZATION_GOVERNANCE_TARGET (
    		OrganizationGovernanceTarget.class,
    		"OGT",
    		R.string.fmm_node_definition__organization_governance_target__label_text,
    		R.drawable.null_drawable,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    ORGANIZATION_LOCK_CONFIG (
    		OrganizationLockConfig.class,
    		"OLC",
    		R.string.fmm_node_definition__organization_lock_config__label_text,
    		R.drawable.null_drawable,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    ORGANIZATION_PARTICIPATION (
    		OrganizationParticipation.class,
    		"OPN",
    		R.string.fmm_node_definition__organization_participation__label_text,
    		R.drawable.null_drawable,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    PORTFOLIO (
    		Portfolio.class,
    		"PFO",
    		R.string.fmm_node_definition__portfolio__label_text,
    		R.drawable.fmm_noun__portfolio__gray,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    PORTFOLIO_LINK_TO_PROJECT (
    		PortfolioLinkToProject.class,
    		"PLP",
    		R.string.fmm_node_definition__portfolio_linkto_project__label_text,
    		R.drawable.null_drawable,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    PROJECT (
    		Project.class,
    		"PRJ",
    		R.string.fmm_node_definition__project__label_text,
    		R.drawable.fmm_noun__project__gray,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    PROJECT_ASSET (
    		ProjectAsset.class,
    		"PAT",
    		R.string.fmm_node_definition__project_asset__label_text,
    		R.drawable.fmm_noun__project_asset__gray,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    PROJECT_ASSET_LINK_TO_WORK_PACKAGE (
    		ProjectAssetLinkToWorkPackage.class,
    		"ALW",
    		R.string.fmm_node_definition__project_asset_link_to_work_package__label_text,
    		R.drawable.null_drawable,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    PROJECT_LINK_TO_PROJECT_ASSET (
    		ProjectLinkToProjectAsset.class,
    		"PLA",
    		R.string.fmm_node_definition__project_link_to_project_asset__label_text,
    		R.drawable.null_drawable,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    REPOSITORY (
    		FmmRepository.class,
    		"RPY",
    		R.string.fmm_node_definition__repository__label_text,
    		R.drawable.repository,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    SERVICE_DELIVERY_COMMITMENT (
    		ServiceDeliveryCommitment.class,
    		"SDC",
    		R.string.fmm_node_definition__service_delivery_commitment__label_text,
    		R.drawable.commitment__none,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    SERVICE_OFFERING (
    		ServiceOffering.class,
    		"SOG",
    		R.string.fmm_node_definition__service_offering__label_text,
    		R.drawable.fmm_noun__service_offering,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    SERVICE_OFFERING_SLA (
    		ServiceOfferingSla.class,
    		"SOS",
    		R.string.fmm_node_definition__service_offering_sla__label_text,
    		R.drawable.fmm_noun__service_level_agreement__gray,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    SERVICE_REQUEST (
    		ServiceRequest.class,
    		"SRT",
    		R.string.fmm_node_definition__service_request__label_text,
    		R.drawable.fmm_noun__service_request__gray,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    SERVICE_REQUEST_LINK_TO_WORK_TASK (
    		ServiceRequestLinkToWorkTask.class,
    		"RLT",
    		R.string.fmm_node_definition__service_request_link_to_work_task__label_text,
    		R.drawable.null_drawable,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    SERVICE_REQUEST_TRIAGE_LOG (
    		ServiceRequestTriageLog.class,
    		"RTL",
    		R.string.fmm_node_definition__service_request_triage_log__label_text,
    		R.drawable.fmm_noun__service_request_triage_log__gray,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    STRATEGIC_COMMITMENT (
    		StrategicCommitment.class,
    		"SCT",
    		R.string.fmm_node_definition__strategic_commitment__label_text,
    		R.drawable.commitment__none,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    STRATEGIC_MILESTONE (
    		StrategicMilestone.class,
    		"SMN",
    		R.string.fmm_node_definition__strategic_milestone__label_text,
    		R.drawable.fmm_noun__strategic_milestone__gray,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    STRATEGIC_TEAM (
    		StrategicTeam.class,
    		"STM",
    		R.string.fmm_node_definition__strategic_team__label_text,
    		R.drawable.fmm_noun__strategic_team,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    STRATEGIC_TEAM_COMMUNITY_MEMBER (
    		StrategicTeamCommunityMember.class,
    		"STM",
    		R.string.fmm_node_definition__strategic_team_community_member__label_text,
    		R.drawable.fmm_noun__strategic_team,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    TEAM_MEMBER_STATUS (
    		TeamMemberStatus.class,
    		"TMS",
    		R.string.fmm_node_definition__team_member_status__label_text,
    		R.drawable.null_drawable,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
	TRIBKN_ELEMENT (
			TribKnElement.class,
			"TRE",
			R.string.fmm_node_definition__tribkn_element__label_text,
			R.drawable.null_drawable,
			new HashMap<FmmNodeGlyphType, Integer>() ),
	TRIBKN_QUALITY_ENUMERATION (
			TribKnQualityEnumeration.class,
			"TRN",
			R.string.fmm_node_definition__tribkn_quality_enumeration__label_text,
			R.drawable.null_drawable,
			new HashMap<FmmNodeGlyphType, Integer>() ),
	TRIBKN_QUALITY_NORMALIZED__DESCRIPTION (
			TribKnQualityNormalizedDescription.class,
			"TRD",
			R.string.fmm_node_definition__tribkn_quality_normalized_description__label_text,
			R.drawable.null_drawable,
			new HashMap<FmmNodeGlyphType, Integer>() ),
    WORK_PACKAGE (
    		WorkPackage.class,
    		"WPG",
    		R.string.fmm_node_definition__work_package__label_text,
    		R.drawable.fmm_noun__work_package__gray,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    WORK_PACKAGE_LINK_TO_WORK_TASK (
    		WorkPackageLinkToWorkTask.class,
    		"PLT",
    		R.string.fmm_node_definition__work_package_link_to_work_task__label_text,
    		R.drawable.null_drawable,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    WORK_PLAN (
    		WorkPlan.class,
    		"WPN",
    		R.string.fmm_node_definition__work_plan__label_text,
    		R.drawable.fmm_noun__work_plan__gray,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    WORK_TASK (
    		WorkTask.class,
    		"WTK",
    		R.string.fmm_node_definition__work_task__label_text,
    		R.drawable.fmm_noun__work_task__gray,
    		new HashMap<FmmNodeGlyphType, Integer>() ),
    WORK_TASK_ASSIGNMENT (
    		WorkTaskAssignment.class,
    		"WTA",
    		R.string.fmm_node_definition__work_task_assignment__label_text,
    		R.drawable.null_drawable,
    		new HashMap<FmmNodeGlyphType, Integer>() );
	
	public static final String name_COLUMN_1 = "node_name";
	public static final String name_COLUMN_2 = "description";
	public static final String name_COLUMN_3 = "node_id_code";
	
	public static final ArrayList<FmmNodeDictionary> DATABASE_LOAD_ORDER = new ArrayList<FmmNodeDictionary>(
			Arrays.asList(
					FmmNodeDictionary.COMMUNITY_MEMBER,
					FmmNodeDictionary.REPOSITORY,
					FmmNodeDictionary.ORGANIZATION,
					FmmNodeDictionary.FLYWHEEL_TEAM,
					FmmNodeDictionary.FISCAL_YEAR,
					FmmNodeDictionary.STRATEGIC_MILESTONE,
					FmmNodeDictionary.PROJECT,
					FmmNodeDictionary.PROJECT_ASSET,
					FmmNodeDictionary.PROJECT_ASSET_LINK_TO_WORK_PACKAGE,
					FmmNodeDictionary.STRATEGIC_COMMITMENT,
					FmmNodeDictionary.WORK_PACKAGE ) );
	
	private static final HashMap<String, FmmNodeDictionary> NODE_TYPE_CODE_MAP = new HashMap<String, FmmNodeDictionary>();
	static {
		putNodeTypeCodeMapEntry(FmmNodeDictionary.ASSIGNMENT_COMMITMENT_TYPE);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.BOOKSHELF);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.BOOKSHELF_LINK_TO_NOTEBOOK);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.COMMUNITY_MEMBER);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.COMMUNITY_MEMBER_FLYWHEEL_TEAM_GOVERNANCE_AUTHORITY);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.COMMUNITY_MEMBER_ORGANIZATION_GOVERNANCE_AUTHORITY);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.COMMUNITY_MEMBER_STATUS);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.COMPLETABLE_WORK_STATUS);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.COMPLETION_COMMITMENT_TYPE);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.DISCUSSION_TOPIC);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.DISCUSSION_TOPIC_LINK_TO_NODE_FRAG_AUDIT_BLOCK);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.FACILITATION_ISSUE_LINK_TO_WORK_TASK);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.FACILITATION_ISSUE);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.FACILITATION_ISSUE_LINK_TO_WORK_TASK);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.FISCAL_YEAR);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.FLYWHEEL_COMMITMENT);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.FLYWHEEL_MILESTONE);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.FLYWHEEL_TEAM);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.FLYWHEEL_TEAM_COMMUNITY_MEMBER);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.FLYWHEEL_TEAM_WORK_TASK_BUDGET);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.FSE_DOCUMENT);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.FSE_PARAGRAPH);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.FUNCTIONAL_TEAM);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.FUNCTIONAL_TEAM_COMMUNITY_MEMBER);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.GOVERNANCE_PARTICIPATION_TYPE);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.GOVERNANCE_ROLE);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.GOVERNANCE_TARGET);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.ISSUE_STATUS);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.LOCK_CONFIG);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.LOCK_TYPE);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.NODE_FRAG_AUDIT_BLOCK);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.NODE_FRAG_GOVERNANCE);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.NOTEBOOK);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.NOTEBOOK_LINK_TO_FACILITATION_ISSUE);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.ORGANIZATION);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.ORGANIZATION_COMMUNITY_MEMBER);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.ORGANIZATION_GOVERNANCE_TARGET);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.ORGANIZATION_LOCK_CONFIG);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.ORGANIZATION_PARTICIPATION);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.PORTFOLIO);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.PORTFOLIO_LINK_TO_PROJECT);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.PROJECT);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.PROJECT_ASSET);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.PROJECT_ASSET_LINK_TO_WORK_PACKAGE);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.PROJECT_LINK_TO_PROJECT_ASSET);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.REPOSITORY);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.SERVICE_DELIVERY_COMMITMENT);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.SERVICE_OFFERING);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.SERVICE_OFFERING_SLA);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.SERVICE_REQUEST);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.SERVICE_REQUEST_LINK_TO_WORK_TASK);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.SERVICE_REQUEST_TRIAGE_LOG);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.STRATEGIC_COMMITMENT);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.STRATEGIC_MILESTONE);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.STRATEGIC_TEAM);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.STRATEGIC_TEAM_COMMUNITY_MEMBER);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.TEAM_MEMBER_STATUS);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.TRIBKN_QUALITY_ENUMERATION);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.TRIBKN_ELEMENT);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.TRIBKN_QUALITY_NORMALIZED__DESCRIPTION);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.WORK_PACKAGE);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.WORK_PACKAGE_LINK_TO_WORK_TASK);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.WORK_PLAN);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.WORK_TASK);
		putNodeTypeCodeMapEntry(FmmNodeDictionary.WORK_TASK_ASSIGNMENT);
	}
	
	private static void putNodeTypeCodeMapEntry(FmmNodeDictionary anFmmNodeDictionaryEntry) {
		FmmNodeDictionary.NODE_TYPE_CODE_MAP.put(anFmmNodeDictionaryEntry.getNodeTypeCode(), anFmmNodeDictionaryEntry);
	}
	
	public static FmmNodeDictionary getEntryForNodeTypeCode(String aNodeIdCode) {
		return FmmNodeDictionary.NODE_TYPE_CODE_MAP.get(aNodeIdCode);
	}
	
	public static FmmNodeDictionary getEntryForNodeIdString(String aNodeIdString) {
		return getEntryForNodeTypeCode(aNodeIdString.substring(0, 3));
	}
	
	public static FmmNodeDictionary getEntryForNodeId(NodeId aNodeId) {
		return getEntryForNodeTypeCode(aNodeId.getNodeTypeCode());
	}
	
	private static final HashMap<String, FmmNodeDictionary> NODE_CLASS_NAME_MAP = new HashMap<String, FmmNodeDictionary>();
	static {
		putNodeClassNameMapEntry(FmmNodeDictionary.ASSIGNMENT_COMMITMENT_TYPE);
		putNodeClassNameMapEntry(FmmNodeDictionary.BOOKSHELF);
		putNodeClassNameMapEntry(FmmNodeDictionary.BOOKSHELF_LINK_TO_NOTEBOOK);
		putNodeClassNameMapEntry(FmmNodeDictionary.COMMUNITY_MEMBER);
		putNodeClassNameMapEntry(FmmNodeDictionary.COMMUNITY_MEMBER_FLYWHEEL_TEAM_GOVERNANCE_AUTHORITY);
		putNodeClassNameMapEntry(FmmNodeDictionary.COMMUNITY_MEMBER_ORGANIZATION_GOVERNANCE_AUTHORITY);
		putNodeClassNameMapEntry(FmmNodeDictionary.COMMUNITY_MEMBER_STATUS);
		putNodeClassNameMapEntry(FmmNodeDictionary.COMPLETABLE_WORK_STATUS);
		putNodeClassNameMapEntry(FmmNodeDictionary.COMPLETION_COMMITMENT_TYPE);
		putNodeClassNameMapEntry(FmmNodeDictionary.DISCUSSION_TOPIC);
		putNodeClassNameMapEntry(FmmNodeDictionary.DISCUSSION_TOPIC_LINK_TO_NODE_FRAG_AUDIT_BLOCK);
		putNodeClassNameMapEntry(FmmNodeDictionary.FACILITATION_ISSUE);
		putNodeClassNameMapEntry(FmmNodeDictionary.FACILITATION_ISSUE_LINK_TO_WORK_TASK);
		putNodeClassNameMapEntry(FmmNodeDictionary.FISCAL_YEAR);
		putNodeClassNameMapEntry(FmmNodeDictionary.FLYWHEEL_COMMITMENT);
		putNodeClassNameMapEntry(FmmNodeDictionary.FLYWHEEL_MILESTONE);
		putNodeClassNameMapEntry(FmmNodeDictionary.FLYWHEEL_TEAM);
		putNodeClassNameMapEntry(FmmNodeDictionary.FLYWHEEL_TEAM_COMMUNITY_MEMBER);
		putNodeClassNameMapEntry(FmmNodeDictionary.FLYWHEEL_TEAM_WORK_TASK_BUDGET);
		putNodeClassNameMapEntry(FmmNodeDictionary.FSE_DOCUMENT);
		putNodeClassNameMapEntry(FmmNodeDictionary.FSE_PARAGRAPH);
		putNodeClassNameMapEntry(FmmNodeDictionary.FUNCTIONAL_TEAM);
		putNodeClassNameMapEntry(FmmNodeDictionary.FUNCTIONAL_TEAM_COMMUNITY_MEMBER);
		putNodeClassNameMapEntry(FmmNodeDictionary.GOVERNANCE_PARTICIPATION_TYPE);
		putNodeClassNameMapEntry(FmmNodeDictionary.GOVERNANCE_ROLE);
		putNodeClassNameMapEntry(FmmNodeDictionary.GOVERNANCE_TARGET);
		putNodeClassNameMapEntry(FmmNodeDictionary.ISSUE_STATUS);
		putNodeClassNameMapEntry(FmmNodeDictionary.LOCK_CONFIG);
		putNodeClassNameMapEntry(FmmNodeDictionary.LOCK_TYPE);
		putNodeClassNameMapEntry(FmmNodeDictionary.NODE_FRAG_AUDIT_BLOCK);
		putNodeClassNameMapEntry(FmmNodeDictionary.NODE_FRAG_GOVERNANCE);
		putNodeClassNameMapEntry(FmmNodeDictionary.NOTEBOOK);
		putNodeClassNameMapEntry(FmmNodeDictionary.NOTEBOOK_LINK_TO_FACILITATION_ISSUE);
		putNodeClassNameMapEntry(FmmNodeDictionary.ORGANIZATION);
		putNodeClassNameMapEntry(FmmNodeDictionary.ORGANIZATION_COMMUNITY_MEMBER);
		putNodeClassNameMapEntry(FmmNodeDictionary.ORGANIZATION_GOVERNANCE_TARGET);
		putNodeClassNameMapEntry(FmmNodeDictionary.ORGANIZATION_LOCK_CONFIG);
		putNodeClassNameMapEntry(FmmNodeDictionary.ORGANIZATION_PARTICIPATION);
		putNodeClassNameMapEntry(FmmNodeDictionary.PORTFOLIO);
		putNodeClassNameMapEntry(FmmNodeDictionary.PORTFOLIO_LINK_TO_PROJECT);
		putNodeClassNameMapEntry(FmmNodeDictionary.PROJECT);
		putNodeClassNameMapEntry(FmmNodeDictionary.PROJECT_ASSET);
		putNodeClassNameMapEntry(FmmNodeDictionary.PROJECT_ASSET_LINK_TO_WORK_PACKAGE);
		putNodeClassNameMapEntry(FmmNodeDictionary.PROJECT_LINK_TO_PROJECT_ASSET);
		putNodeClassNameMapEntry(FmmNodeDictionary.REPOSITORY);
		putNodeClassNameMapEntry(FmmNodeDictionary.SERVICE_DELIVERY_COMMITMENT);
		putNodeClassNameMapEntry(FmmNodeDictionary.SERVICE_OFFERING);
		putNodeClassNameMapEntry(FmmNodeDictionary.SERVICE_OFFERING_SLA);
		putNodeClassNameMapEntry(FmmNodeDictionary.SERVICE_REQUEST);
		putNodeClassNameMapEntry(FmmNodeDictionary.SERVICE_REQUEST_LINK_TO_WORK_TASK);
		putNodeClassNameMapEntry(FmmNodeDictionary.SERVICE_REQUEST_TRIAGE_LOG);
		putNodeClassNameMapEntry(FmmNodeDictionary.STRATEGIC_COMMITMENT);
		putNodeClassNameMapEntry(FmmNodeDictionary.STRATEGIC_MILESTONE);
		putNodeClassNameMapEntry(FmmNodeDictionary.STRATEGIC_TEAM);
		putNodeClassNameMapEntry(FmmNodeDictionary.STRATEGIC_TEAM_COMMUNITY_MEMBER);
		putNodeClassNameMapEntry(FmmNodeDictionary.TEAM_MEMBER_STATUS);
		putNodeClassNameMapEntry(FmmNodeDictionary.TRIBKN_QUALITY_ENUMERATION);
		putNodeClassNameMapEntry(FmmNodeDictionary.TRIBKN_ELEMENT);
		putNodeClassNameMapEntry(FmmNodeDictionary.TRIBKN_QUALITY_NORMALIZED__DESCRIPTION);
		putNodeClassNameMapEntry(FmmNodeDictionary.WORK_PACKAGE);
		putNodeClassNameMapEntry(FmmNodeDictionary.WORK_PACKAGE_LINK_TO_WORK_TASK);
		putNodeClassNameMapEntry(FmmNodeDictionary.WORK_PLAN);
		putNodeClassNameMapEntry(FmmNodeDictionary.WORK_TASK);
		putNodeClassNameMapEntry(FmmNodeDictionary.WORK_TASK_ASSIGNMENT);
	}
	
	private static void putNodeClassNameMapEntry(FmmNodeDictionary anFmmNodeDictionaryEntry) {
		FmmNodeDictionary.NODE_CLASS_NAME_MAP.put(anFmmNodeDictionaryEntry.getName(), anFmmNodeDictionaryEntry);
	}
	
	public static FmmNodeDictionary getEntryForNodeClassName(String aNodeTypeName) {
		return FmmNodeDictionary.NODE_CLASS_NAME_MAP.get(aNodeTypeName);
	}
	
	private static final HashMap<Class<? extends FmmNode>, FmmNodeDictionary> NODE_CLASS_MAP = new HashMap<Class<? extends FmmNode>, FmmNodeDictionary>();
	static {
		putClassMapEntry(FmmNodeDictionary.ASSIGNMENT_COMMITMENT_TYPE);
		putClassMapEntry(FmmNodeDictionary.BOOKSHELF);
		putClassMapEntry(FmmNodeDictionary.BOOKSHELF_LINK_TO_NOTEBOOK);
		putClassMapEntry(FmmNodeDictionary.COMMUNITY_MEMBER);
		putClassMapEntry(FmmNodeDictionary.COMMUNITY_MEMBER_FLYWHEEL_TEAM_GOVERNANCE_AUTHORITY);
		putClassMapEntry(FmmNodeDictionary.COMMUNITY_MEMBER_ORGANIZATION_GOVERNANCE_AUTHORITY);
		putClassMapEntry(FmmNodeDictionary.COMMUNITY_MEMBER_STATUS);
		putClassMapEntry(FmmNodeDictionary.COMPLETABLE_WORK_STATUS);
		putClassMapEntry(FmmNodeDictionary.COMPLETION_COMMITMENT_TYPE);
		putClassMapEntry(FmmNodeDictionary.DISCUSSION_TOPIC);
		putClassMapEntry(FmmNodeDictionary.DISCUSSION_TOPIC_LINK_TO_NODE_FRAG_AUDIT_BLOCK);
		putClassMapEntry(FmmNodeDictionary.FACILITATION_ISSUE);
		putClassMapEntry(FmmNodeDictionary.FACILITATION_ISSUE_LINK_TO_WORK_TASK);
		putClassMapEntry(FmmNodeDictionary.FISCAL_YEAR);
		putClassMapEntry(FmmNodeDictionary.FLYWHEEL_COMMITMENT);
		putClassMapEntry(FmmNodeDictionary.FLYWHEEL_MILESTONE);
		putClassMapEntry(FmmNodeDictionary.FLYWHEEL_TEAM);
		putClassMapEntry(FmmNodeDictionary.FLYWHEEL_TEAM_COMMUNITY_MEMBER);
		putClassMapEntry(FmmNodeDictionary.FLYWHEEL_TEAM_WORK_TASK_BUDGET);
		putClassMapEntry(FmmNodeDictionary.FSE_DOCUMENT);
		putClassMapEntry(FmmNodeDictionary.FSE_PARAGRAPH);
		putClassMapEntry(FmmNodeDictionary.FUNCTIONAL_TEAM);
		putClassMapEntry(FmmNodeDictionary.FUNCTIONAL_TEAM_COMMUNITY_MEMBER);
		putClassMapEntry(FmmNodeDictionary.GOVERNANCE_PARTICIPATION_TYPE);
		putClassMapEntry(FmmNodeDictionary.GOVERNANCE_ROLE);
		putClassMapEntry(FmmNodeDictionary.GOVERNANCE_TARGET);
		putClassMapEntry(FmmNodeDictionary.ISSUE_STATUS);
		putClassMapEntry(FmmNodeDictionary.LOCK_CONFIG);
		putClassMapEntry(FmmNodeDictionary.LOCK_TYPE);
		putClassMapEntry(FmmNodeDictionary.NODE_FRAG_AUDIT_BLOCK);
		putClassMapEntry(FmmNodeDictionary.NODE_FRAG_GOVERNANCE);
		putClassMapEntry(FmmNodeDictionary.NOTEBOOK);
		putClassMapEntry(FmmNodeDictionary.NOTEBOOK_LINK_TO_FACILITATION_ISSUE);
		putClassMapEntry(FmmNodeDictionary.ORGANIZATION);
		putClassMapEntry(FmmNodeDictionary.ORGANIZATION_COMMUNITY_MEMBER);
		putClassMapEntry(FmmNodeDictionary.ORGANIZATION_GOVERNANCE_TARGET);
		putClassMapEntry(FmmNodeDictionary.ORGANIZATION_LOCK_CONFIG);
		putClassMapEntry(FmmNodeDictionary.ORGANIZATION_PARTICIPATION);
		putClassMapEntry(FmmNodeDictionary.PORTFOLIO);
		putClassMapEntry(FmmNodeDictionary.PORTFOLIO_LINK_TO_PROJECT);
		putClassMapEntry(FmmNodeDictionary.PROJECT);
		putClassMapEntry(FmmNodeDictionary.PROJECT_ASSET);
		putClassMapEntry(FmmNodeDictionary.PROJECT_ASSET_LINK_TO_WORK_PACKAGE);
		putClassMapEntry(FmmNodeDictionary.PROJECT_LINK_TO_PROJECT_ASSET);
		putClassMapEntry(FmmNodeDictionary.REPOSITORY);
		putClassMapEntry(FmmNodeDictionary.SERVICE_DELIVERY_COMMITMENT);
		putClassMapEntry(FmmNodeDictionary.SERVICE_OFFERING);
		putClassMapEntry(FmmNodeDictionary.SERVICE_OFFERING_SLA);
		putClassMapEntry(FmmNodeDictionary.SERVICE_REQUEST);
		putClassMapEntry(FmmNodeDictionary.SERVICE_REQUEST_LINK_TO_WORK_TASK);
		putClassMapEntry(FmmNodeDictionary.SERVICE_REQUEST_TRIAGE_LOG);
		putClassMapEntry(FmmNodeDictionary.STRATEGIC_COMMITMENT);
		putClassMapEntry(FmmNodeDictionary.STRATEGIC_MILESTONE);
		putClassMapEntry(FmmNodeDictionary.STRATEGIC_TEAM);
		putClassMapEntry(FmmNodeDictionary.STRATEGIC_TEAM_COMMUNITY_MEMBER);
		putClassMapEntry(FmmNodeDictionary.TEAM_MEMBER_STATUS);
		putClassMapEntry(FmmNodeDictionary.TRIBKN_QUALITY_ENUMERATION);
		putClassMapEntry(FmmNodeDictionary.TRIBKN_ELEMENT);
		putClassMapEntry(FmmNodeDictionary.TRIBKN_QUALITY_NORMALIZED__DESCRIPTION);
		putClassMapEntry(FmmNodeDictionary.WORK_PACKAGE);
		putClassMapEntry(FmmNodeDictionary.WORK_PACKAGE_LINK_TO_WORK_TASK);
		putClassMapEntry(FmmNodeDictionary.WORK_PLAN);
		putClassMapEntry(FmmNodeDictionary.WORK_TASK);
		putClassMapEntry(FmmNodeDictionary.WORK_TASK_ASSIGNMENT);
	}
	
	private static void putClassMapEntry(FmmNodeDictionary anFmmNodeDictionaryEntry) {
		FmmNodeDictionary.NODE_CLASS_MAP.put(anFmmNodeDictionaryEntry.getNodeClass(), anFmmNodeDictionaryEntry);
	}
	
	public static FmmNodeDictionary getEntryForClass(Class<? extends FmmNode> aNodeClass) {
		return FmmNodeDictionary.NODE_CLASS_MAP.get(aNodeClass);
	}
	
	static {  // initialize nodeGlyphResourceIdMap(s)
		//  BOOKSHELF
		FmmNodeDictionary.BOOKSHELF.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.ADD_TO, R.drawable.fmm_noun__bookshelf__add_to);
		FmmNodeDictionary.BOOKSHELF.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.ALL, R.drawable.fmm_noun__bookshelf__all_notebooks);
		FmmNodeDictionary.BOOKSHELF.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.DESTROY, R.drawable.fmm_noun__bookshelf__destroy);
		FmmNodeDictionary.BOOKSHELF.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.EDIT, R.drawable.fmm_noun__bookshelf__edit);
		FmmNodeDictionary.BOOKSHELF.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.GRAY, R.drawable.fmm_noun__bookshelf__gray);
		FmmNodeDictionary.BOOKSHELF.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.GREEN, R.drawable.fmm_noun__bookshelf__green);
		FmmNodeDictionary.BOOKSHELF.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.NEW, R.drawable.fmm_noun__bookshelf__new);
		FmmNodeDictionary.BOOKSHELF.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.ORANGE, R.drawable.fmm_noun__bookshelf__orange);
		FmmNodeDictionary.BOOKSHELF.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.ORPHAN, R.drawable.fmm_noun__bookshelf__orphan_notebooks);
		FmmNodeDictionary.BOOKSHELF.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.PINK, R.drawable.fmm_noun__bookshelf__pink);
		FmmNodeDictionary.BOOKSHELF.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.REMOVE, R.drawable.fmm_noun__bookshelf__remove_notebook);
		FmmNodeDictionary.BOOKSHELF.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.RENAME, R.drawable.fmm_noun__bookshelf__rename);
		FmmNodeDictionary.BOOKSHELF.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.YELLOW, R.drawable.fmm_noun__bookshelf__yellow);
		//  DISCUSSION TOPIC
		FmmNodeDictionary.FACILITATION_ISSUE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.ADD_TO, R.drawable.fmm_noun__discussion_topic__add_item);
		FmmNodeDictionary.FACILITATION_ISSUE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.ADD, R.drawable.fmm_noun__discussion_topic__add);
		FmmNodeDictionary.FACILITATION_ISSUE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.COUNT_GREEN, R.drawable.fmm_noun__discussion_topic_count__green_of_total);
		FmmNodeDictionary.FACILITATION_ISSUE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.DESTROY, R.drawable.fmm_noun__discussion_topic__destroy);
		FmmNodeDictionary.FACILITATION_ISSUE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.EDIT, R.drawable.fmm_noun__discussion_topic__edit);
		FmmNodeDictionary.FACILITATION_ISSUE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.GRAY, R.drawable.fmm_noun__discussion_topic__gray);
		FmmNodeDictionary.FACILITATION_ISSUE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.GREEN, R.drawable.fmm_noun__discussion_topic__green);
		FmmNodeDictionary.FACILITATION_ISSUE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.MOVE, R.drawable.fmm_noun__discussion_topic__move);
		FmmNodeDictionary.FACILITATION_ISSUE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.NEW, R.drawable.fmm_noun__discussion_topic__new);
		FmmNodeDictionary.FACILITATION_ISSUE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.ORANGE, R.drawable.fmm_noun__discussion_topic__orange);
		FmmNodeDictionary.FACILITATION_ISSUE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.PINK, R.drawable.fmm_noun__discussion_topic__pink);
		FmmNodeDictionary.FACILITATION_ISSUE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.REMOVE, R.drawable.fmm_noun__discussion_topic__remove);
		FmmNodeDictionary.FACILITATION_ISSUE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.RENAME, R.drawable.fmm_noun__discussion_topic__rename);
		FmmNodeDictionary.FACILITATION_ISSUE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.YELLOW, R.drawable.fmm_noun__discussion_topic__yellow);
		//  FACILITATION ISSUE
		FmmNodeDictionary.FACILITATION_ISSUE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.DESTROY, R.drawable.fmm_noun__facilitation_issue__destroy);
		FmmNodeDictionary.FACILITATION_ISSUE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.EDIT, R.drawable.fmm_noun__facilitation_issue__edit);
		FmmNodeDictionary.FACILITATION_ISSUE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.GRAY, R.drawable.fmm_noun__facilitation_issue__gray);
		FmmNodeDictionary.FACILITATION_ISSUE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.GREEN, R.drawable.fmm_noun__facilitation_issue__green);
		FmmNodeDictionary.FACILITATION_ISSUE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.MOVE, R.drawable.fmm_noun__facilitation_issue__move);
		FmmNodeDictionary.FACILITATION_ISSUE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.NEW, R.drawable.fmm_noun__facilitation_issue__new);
		FmmNodeDictionary.FACILITATION_ISSUE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.ORANGE, R.drawable.fmm_noun__facilitation_issue__orange);
		FmmNodeDictionary.FACILITATION_ISSUE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.PINK, R.drawable.fmm_noun__facilitation_issue__pink);
		FmmNodeDictionary.FACILITATION_ISSUE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.RENAME, R.drawable.fmm_noun__facilitation_issue__rename);
		FmmNodeDictionary.FACILITATION_ISSUE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.YELLOW, R.drawable.fmm_noun__facilitation_issue__yellow);
		//  FISCAL YEAR
		FmmNodeDictionary.FISCAL_YEAR.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.DESTROY, R.drawable.fmm_noun__fiscal_year__destroy);
		FmmNodeDictionary.FISCAL_YEAR.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.EDIT, R.drawable.fmm_noun__fiscal_year__edit);
		FmmNodeDictionary.FISCAL_YEAR.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.GRAY, R.drawable.fmm_noun__fiscal_year__gray);
		FmmNodeDictionary.FISCAL_YEAR.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.GREEN, R.drawable.fmm_noun__fiscal_year__green);
		FmmNodeDictionary.FISCAL_YEAR.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.NEW, R.drawable.fmm_noun__fiscal_year__new);
		FmmNodeDictionary.FISCAL_YEAR.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.ORANGE, R.drawable.fmm_noun__fiscal_year__orange);
		FmmNodeDictionary.FISCAL_YEAR.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.PINK, R.drawable.fmm_noun__fiscal_year__pink);
		FmmNodeDictionary.FISCAL_YEAR.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.RENAME, R.drawable.fmm_noun__fiscal_year__rename);
		FmmNodeDictionary.FISCAL_YEAR.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.YELLOW, R.drawable.fmm_noun__fiscal_year__yellow);
		//  FLYWHEEL MILESTONE
		FmmNodeDictionary.FLYWHEEL_MILESTONE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.DESTROY, R.drawable.fmm_noun__flywheel_milestone__destroy);
		FmmNodeDictionary.FLYWHEEL_MILESTONE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.EDIT, R.drawable.fmm_noun__flywheel_milestone__edit);
		FmmNodeDictionary.FLYWHEEL_MILESTONE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.GRAY, R.drawable.fmm_noun__flywheel_milestone__gray);
		FmmNodeDictionary.FLYWHEEL_MILESTONE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.GREEN, R.drawable.fmm_noun__flywheel_milestone__green);
		FmmNodeDictionary.FLYWHEEL_MILESTONE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.MOVE, R.drawable.fmm_noun__flywheel_milestone__move);
		FmmNodeDictionary.FLYWHEEL_MILESTONE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.NEW, R.drawable.fmm_noun__flywheel_milestone__new);
		FmmNodeDictionary.FLYWHEEL_MILESTONE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.ORANGE, R.drawable.fmm_noun__flywheel_milestone__orange);
		FmmNodeDictionary.FLYWHEEL_MILESTONE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.PINK, R.drawable.fmm_noun__flywheel_milestone__pink);
		FmmNodeDictionary.FLYWHEEL_MILESTONE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.QUESTION, R.drawable.fmm_noun__flywheel_milestone__question);
		FmmNodeDictionary.FLYWHEEL_MILESTONE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.RENAME, R.drawable.fmm_noun__flywheel_milestone__rename);
		FmmNodeDictionary.FLYWHEEL_MILESTONE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.YELLOW, R.drawable.fmm_noun__flywheel_milestone__yellow);
		//  FSE_DOCUMENT
		FmmNodeDictionary.FSE_DOCUMENT.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.EDIT, R.drawable.fse_document__edit);
		FmmNodeDictionary.FSE_DOCUMENT.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.GRAY, R.drawable.fse_document__gray);
		FmmNodeDictionary.FSE_DOCUMENT.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.GREEN, R.drawable.fse_document__green);
		FmmNodeDictionary.FSE_DOCUMENT.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.LOCK, R.drawable.fse_document__locked);
		FmmNodeDictionary.FSE_DOCUMENT.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.ORANGE, R.drawable.fse_document__orange);
		FmmNodeDictionary.FSE_DOCUMENT.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.PINK, R.drawable.fse_document__pink);
		FmmNodeDictionary.FSE_DOCUMENT.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.YELLOW, R.drawable.fse_document__yellow);
		//  FSE_PARAGRAPH
		FmmNodeDictionary.FSE_PARAGRAPH.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.GRAY, R.drawable.fse_document__gray);
		//  NOTEBOOK
		FmmNodeDictionary.NOTEBOOK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.ADD_ITEM, R.drawable.fmm_noun__notebook__add_item);
		FmmNodeDictionary.NOTEBOOK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.ADD, R.drawable.fmm_noun__notebook__add);
		FmmNodeDictionary.NOTEBOOK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.DESTROY, R.drawable.fmm_noun__notebook__destroy);
		FmmNodeDictionary.NOTEBOOK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.EDIT, R.drawable.fmm_noun__notebook__edit);
		FmmNodeDictionary.NOTEBOOK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.GRAY, R.drawable.fmm_noun__notebook__gray);
		FmmNodeDictionary.NOTEBOOK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.GREEN, R.drawable.fmm_noun__notebook__green);
		FmmNodeDictionary.NOTEBOOK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.MOVE, R.drawable.fmm_noun__notebook__move);
		FmmNodeDictionary.NOTEBOOK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.NEW, R.drawable.fmm_noun__notebook__new);
		FmmNodeDictionary.NOTEBOOK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.ORANGE, R.drawable.fmm_noun__notebook__orange);
		FmmNodeDictionary.NOTEBOOK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.PINK, R.drawable.fmm_noun__notebook__pink);
		FmmNodeDictionary.NOTEBOOK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.QUESTION, R.drawable.fmm_noun__notebook__question);
		FmmNodeDictionary.NOTEBOOK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.REMOVE, R.drawable.fmm_noun__notebook__remove);
		FmmNodeDictionary.NOTEBOOK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.RENAME, R.drawable.fmm_noun__notebook__rename);
		FmmNodeDictionary.NOTEBOOK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.YELLOW, R.drawable.fmm_noun__notebook__yellow);
		//  PORTFOLIO
		FmmNodeDictionary.PORTFOLIO.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.ADD_ITEM, R.drawable.fmm_noun__portfolio__add_item);
		FmmNodeDictionary.PORTFOLIO.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.ALL, R.drawable.fmm_noun__portfolio__all);
		FmmNodeDictionary.PORTFOLIO.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.DESTROY, R.drawable.fmm_noun__portfolio__destroy);
		FmmNodeDictionary.PORTFOLIO.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.EDIT, R.drawable.fmm_noun__portfolio__edit);
		FmmNodeDictionary.PORTFOLIO.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.GRAY, R.drawable.fmm_noun__portfolio__gray);
		FmmNodeDictionary.PORTFOLIO.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.GREEN, R.drawable.fmm_noun__portfolio__green);
		FmmNodeDictionary.PORTFOLIO.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.NEW, R.drawable.fmm_noun__portfolio__new);
		FmmNodeDictionary.PORTFOLIO.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.ORANGE, R.drawable.fmm_noun__portfolio__orange);
		FmmNodeDictionary.PORTFOLIO.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.PINK, R.drawable.fmm_noun__portfolio__pink);
		FmmNodeDictionary.PORTFOLIO.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.QUESTION, R.drawable.fmm_noun__portfolio__question);
		FmmNodeDictionary.PORTFOLIO.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.REMOVE, R.drawable.fmm_noun__portfolio__remove);
		FmmNodeDictionary.PORTFOLIO.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.RENAME, R.drawable.fmm_noun__portfolio__rename);
		FmmNodeDictionary.PORTFOLIO.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.YELLOW, R.drawable.fmm_noun__portfolio__yellow);
		//  PROJECT
		FmmNodeDictionary.PROJECT.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.ADD_ITEM, R.drawable.fmm_noun__project__add_item);
		FmmNodeDictionary.PROJECT.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.ADD, R.drawable.fmm_noun__project__add);
		FmmNodeDictionary.PROJECT.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.DESTROY, R.drawable.fmm_noun__project__destroy);
		FmmNodeDictionary.PROJECT.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.EDIT, R.drawable.fmm_noun__project__edit);
		FmmNodeDictionary.PROJECT.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.GRAY, R.drawable.fmm_noun__project__gray);
		FmmNodeDictionary.PROJECT.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.GREEN, R.drawable.fmm_noun__project__green);
		FmmNodeDictionary.PROJECT.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.MOVE, R.drawable.fmm_noun__project__move);
		FmmNodeDictionary.PROJECT.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.NEW, R.drawable.fmm_noun__project__new);
		FmmNodeDictionary.PROJECT.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.ORANGE, R.drawable.fmm_noun__project__orange);
		FmmNodeDictionary.PROJECT.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.PINK, R.drawable.fmm_noun__project__pink);
		FmmNodeDictionary.PROJECT.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.QUESTION, R.drawable.fmm_noun__project__question);
		FmmNodeDictionary.PROJECT.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.REMOVE, R.drawable.fmm_noun__project__remove);
		FmmNodeDictionary.PROJECT.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.RENAME, R.drawable.fmm_noun__project__rename);
		FmmNodeDictionary.PROJECT.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.YELLOW, R.drawable.fmm_noun__project__yellow);
		//  PROJECT ASSET
		FmmNodeDictionary.PROJECT_ASSET.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.ADD, R.drawable.fmm_noun__project_asset__add);
		FmmNodeDictionary.PROJECT_ASSET.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.DESTROY, R.drawable.fmm_noun__project_asset__destroy);
		FmmNodeDictionary.PROJECT_ASSET.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.EDIT, R.drawable.fmm_noun__project_asset__edit);
		FmmNodeDictionary.PROJECT_ASSET.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.GRAY, R.drawable.fmm_noun__project_asset__gray);
		FmmNodeDictionary.PROJECT_ASSET.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.GREEN, R.drawable.fmm_noun__project_asset__green);
		FmmNodeDictionary.PROJECT_ASSET.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.MOVE, R.drawable.fmm_noun__project_asset__move);
		FmmNodeDictionary.PROJECT_ASSET.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.NEW, R.drawable.fmm_noun__project_asset__new);
		FmmNodeDictionary.PROJECT_ASSET.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.ORANGE, R.drawable.fmm_noun__project_asset__orange);
		FmmNodeDictionary.PROJECT_ASSET.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.PINK, R.drawable.fmm_noun__project_asset__pink);
		FmmNodeDictionary.PROJECT_ASSET.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.QUESTION, R.drawable.fmm_noun__project_asset__question);
		FmmNodeDictionary.PROJECT_ASSET.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.REMOVE, R.drawable.fmm_noun__project_asset__remove);
		FmmNodeDictionary.PROJECT_ASSET.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.RENAME, R.drawable.fmm_noun__project_asset__rename);
		FmmNodeDictionary.PROJECT_ASSET.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.YELLOW, R.drawable.fmm_noun__project_asset__yellow);
		FmmNodeDictionary.PROJECT_ASSET.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.COUNT_GREEN, R.drawable.fmm_noun__project_asset_count__green);
		//  SERVICE REQUEST
		FmmNodeDictionary.SERVICE_REQUEST.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.ADD, R.drawable.fmm_noun__service_request__add);
		FmmNodeDictionary.SERVICE_REQUEST.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.DESTROY, R.drawable.fmm_noun__service_request__destroy);
		FmmNodeDictionary.SERVICE_REQUEST.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.EDIT, R.drawable.fmm_noun__service_request__edit);
		FmmNodeDictionary.SERVICE_REQUEST.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.GRAY, R.drawable.fmm_noun__service_request__gray);
		FmmNodeDictionary.SERVICE_REQUEST.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.GREEN, R.drawable.fmm_noun__service_request__green);
		FmmNodeDictionary.SERVICE_REQUEST.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.MOVE, R.drawable.fmm_noun__service_request__move);
		FmmNodeDictionary.SERVICE_REQUEST.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.NEW, R.drawable.fmm_noun__service_request__new);
		FmmNodeDictionary.SERVICE_REQUEST.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.ORANGE, R.drawable.fmm_noun__service_request__orange);
		FmmNodeDictionary.SERVICE_REQUEST.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.PINK, R.drawable.fmm_noun__service_request__pink);
		FmmNodeDictionary.SERVICE_REQUEST.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.REMOVE, R.drawable.fmm_noun__service_request__remove);
		FmmNodeDictionary.SERVICE_REQUEST.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.RENAME, R.drawable.fmm_noun__service_request__rename);
		FmmNodeDictionary.SERVICE_REQUEST.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.YELLOW, R.drawable.fmm_noun__service_request__yellow);
		//  SERVICE REQUEST TRIAGE LOG	
		FmmNodeDictionary.SERVICE_REQUEST_TRIAGE_LOG.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.GRAY, R.drawable.fmm_noun__service_request_triage_log__gray);
		FmmNodeDictionary.SERVICE_REQUEST_TRIAGE_LOG.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.GREEN, R.drawable.fmm_noun__service_request_triage_log__green);
		FmmNodeDictionary.SERVICE_REQUEST_TRIAGE_LOG.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.ORANGE, R.drawable.fmm_noun__service_request_triage_log__orange);
		FmmNodeDictionary.SERVICE_REQUEST_TRIAGE_LOG.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.PINK, R.drawable.fmm_noun__service_request_triage_log__pink);
		FmmNodeDictionary.SERVICE_REQUEST_TRIAGE_LOG.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.YELLOW, R.drawable.fmm_noun__service_request_triage_log__yellow);
		//  FLYWHEEL MILESTONE	
		FmmNodeDictionary.STRATEGIC_MILESTONE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.ADD_ITEM, R.drawable.fmm_noun__strategic_milestone__add_item);
		FmmNodeDictionary.STRATEGIC_MILESTONE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.ADD, R.drawable.fmm_noun__strategic_milestone__add);
		FmmNodeDictionary.STRATEGIC_MILESTONE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.DESTROY, R.drawable.fmm_noun__strategic_milestone__destroy);
		FmmNodeDictionary.STRATEGIC_MILESTONE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.EDIT, R.drawable.fmm_noun__strategic_milestone__edit);
		FmmNodeDictionary.STRATEGIC_MILESTONE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.GRAY, R.drawable.fmm_noun__strategic_milestone__gray);
		FmmNodeDictionary.STRATEGIC_MILESTONE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.GREEN, R.drawable.fmm_noun__strategic_milestone__green);
		FmmNodeDictionary.STRATEGIC_MILESTONE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.MOVE, R.drawable.fmm_noun__strategic_milestone__move);
		FmmNodeDictionary.STRATEGIC_MILESTONE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.NEW, R.drawable.fmm_noun__strategic_milestone__new);
		FmmNodeDictionary.STRATEGIC_MILESTONE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.ORANGE, R.drawable.fmm_noun__strategic_milestone__orange);
		FmmNodeDictionary.STRATEGIC_MILESTONE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.PINK, R.drawable.fmm_noun__strategic_milestone__pink);
		FmmNodeDictionary.STRATEGIC_MILESTONE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.REMOVE, R.drawable.fmm_noun__strategic_milestone__remove);
		FmmNodeDictionary.STRATEGIC_MILESTONE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.RENAME, R.drawable.fmm_noun__strategic_milestone__rename);
		FmmNodeDictionary.STRATEGIC_MILESTONE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.YELLOW, R.drawable.fmm_noun__strategic_milestone__yellow);
		//  WORK PACKAGE	
		FmmNodeDictionary.WORK_PACKAGE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.ADD_ITEM, R.drawable.fmm_noun__work_package__add_item);
		FmmNodeDictionary.WORK_PACKAGE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.ADD, R.drawable.fmm_noun__work_package__add);
		FmmNodeDictionary.WORK_PACKAGE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.COPY, R.drawable.fmm_noun__work_package__copy);
		FmmNodeDictionary.WORK_PACKAGE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.DESTROY, R.drawable.fmm_noun__work_package__destroy);
		FmmNodeDictionary.WORK_PACKAGE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.EDIT, R.drawable.fmm_noun__work_package__edit);
		FmmNodeDictionary.WORK_PACKAGE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.GRAY, R.drawable.fmm_noun__work_package__gray);
		FmmNodeDictionary.WORK_PACKAGE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.GREEN, R.drawable.fmm_noun__work_package__green);
		FmmNodeDictionary.WORK_PACKAGE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.MOVE, R.drawable.fmm_noun__work_package__move);
		FmmNodeDictionary.WORK_PACKAGE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.NEW, R.drawable.fmm_noun__work_package__new);
		FmmNodeDictionary.WORK_PACKAGE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.ORANGE, R.drawable.fmm_noun__work_package__orange);
		FmmNodeDictionary.WORK_PACKAGE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.PINK, R.drawable.fmm_noun__work_package__pink);
		FmmNodeDictionary.WORK_PACKAGE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.REMOVE, R.drawable.fmm_noun__work_package__remove);
		FmmNodeDictionary.WORK_PACKAGE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.RENAME, R.drawable.fmm_noun__work_package__rename);
		FmmNodeDictionary.WORK_PACKAGE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.YELLOW, R.drawable.fmm_noun__work_package__yellow);
		FmmNodeDictionary.WORK_PACKAGE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.COUNT_GREEN, R.drawable.fmm_noun__work_package_count__green);
		
		FmmNodeDictionary.WORK_PACKAGE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.LIST_ALL, R.drawable.fmm_noun__work_package_list__all);
		FmmNodeDictionary.WORK_PACKAGE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.LIST_GRAY, R.drawable.fmm_noun__work_package_list__gray);
		FmmNodeDictionary.WORK_PACKAGE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.LIST_GREEN, R.drawable.fmm_noun__work_package_list__green);
		FmmNodeDictionary.WORK_PACKAGE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.LIST_MOVE, R.drawable.fmm_noun__work_package_list__move);
		FmmNodeDictionary.WORK_PACKAGE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.LIST_NO_COMMITMENT, R.drawable.fmm_noun__work_package_list__no_commitment);
		FmmNodeDictionary.WORK_PACKAGE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.LIST_PINK, R.drawable.fmm_noun__work_package_list__pink);
		FmmNodeDictionary.WORK_PACKAGE.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.LIST_YELLOW, R.drawable.fmm_noun__work_package_list__yellow);
		//  WORK PLAN
		FmmNodeDictionary.WORK_PLAN.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.ADD, R.drawable.fmm_noun__work_plan__add);
		FmmNodeDictionary.WORK_PLAN.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.DESTROY, R.drawable.fmm_noun__work_plan__destroy);
		FmmNodeDictionary.WORK_PLAN.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.EDIT, R.drawable.fmm_noun__work_plan__edit);
		FmmNodeDictionary.WORK_PLAN.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.GRAY, R.drawable.fmm_noun__work_plan__gray);
		FmmNodeDictionary.WORK_PLAN.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.GREEN, R.drawable.fmm_noun__work_plan__green);
		FmmNodeDictionary.WORK_PLAN.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.MOVE, R.drawable.fmm_noun__work_plan__move);
		FmmNodeDictionary.WORK_PLAN.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.NEW, R.drawable.fmm_noun__work_plan__new);
		FmmNodeDictionary.WORK_PLAN.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.ORANGE, R.drawable.fmm_noun__work_plan__orange);
		FmmNodeDictionary.WORK_PLAN.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.PINK, R.drawable.fmm_noun__work_plan__pink);
		FmmNodeDictionary.WORK_PLAN.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.REMOVE, R.drawable.fmm_noun__work_plan__remove);
		FmmNodeDictionary.WORK_PLAN.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.RENAME, R.drawable.fmm_noun__work_plan__rename);
		FmmNodeDictionary.WORK_PLAN.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.YELLOW, R.drawable.fmm_noun__work_plan__yellow);
		FmmNodeDictionary.WORK_PLAN.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.COUNT_GREEN, R.drawable.fmm_noun__work_plan_count__green);
		//  WORK TASK
		FmmNodeDictionary.WORK_TASK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.ADD, R.drawable.fmm_noun__work_task__add);
		FmmNodeDictionary.WORK_TASK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.DESTROY, R.drawable.fmm_noun__work_task__destroy);
		FmmNodeDictionary.WORK_TASK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.EDIT, R.drawable.fmm_noun__work_task__edit);
		FmmNodeDictionary.WORK_TASK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.GRAY, R.drawable.fmm_noun__work_task__gray);
		FmmNodeDictionary.WORK_TASK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.GREEN, R.drawable.fmm_noun__work_task__green);
		FmmNodeDictionary.WORK_TASK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.MOVE, R.drawable.fmm_noun__work_task__move);
		FmmNodeDictionary.WORK_TASK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.NEW, R.drawable.fmm_noun__work_task__new);
		FmmNodeDictionary.WORK_TASK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.ORANGE, R.drawable.fmm_noun__work_task__orange);
		FmmNodeDictionary.WORK_TASK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.PINK, R.drawable.fmm_noun__work_task__pink);
		FmmNodeDictionary.WORK_TASK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.REMOVE, R.drawable.fmm_noun__work_task__remove);
		FmmNodeDictionary.WORK_TASK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.RENAME, R.drawable.fmm_noun__work_task__rename);
		FmmNodeDictionary.WORK_TASK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.YELLOW, R.drawable.fmm_noun__work_task__yellow);
		FmmNodeDictionary.WORK_TASK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.COUNT_GREEN, R.drawable.fmm_noun__work_task_count__green);

		FmmNodeDictionary.WORK_TASK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.LIST_ALL, R.drawable.fmm_noun__work_task_list__all);
		FmmNodeDictionary.WORK_TASK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.LIST_GRAY, R.drawable.fmm_noun__work_task_list__gray);
		FmmNodeDictionary.WORK_TASK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.LIST_GREEN, R.drawable.fmm_noun__work_task_list__green);
		FmmNodeDictionary.WORK_TASK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.LIST_MOVE_GRAY, R.drawable.fmm_noun__work_task_list__move_gray);
		FmmNodeDictionary.WORK_TASK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.LIST_MOVE_NOT_GREEN, R.drawable.fmm_noun__work_task_list__move_not_green);
		FmmNodeDictionary.WORK_TASK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.LIST_MOVE_PINK, R.drawable.fmm_noun__work_task_list__move_pink);
		FmmNodeDictionary.WORK_TASK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.LIST_MOVE_YELLOW, R.drawable.fmm_noun__work_task_list__move_yellow);
		FmmNodeDictionary.WORK_TASK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.LIST_MOVE, R.drawable.fmm_noun__work_task_list__move);
		FmmNodeDictionary.WORK_TASK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.LIST_PINK, R.drawable.fmm_noun__work_task_list__pink);
		FmmNodeDictionary.WORK_TASK.getNodeGlyphResourceIdMap().put(
				FmmNodeGlyphType.LIST_YELLOW, R.drawable.fmm_noun__work_task_list__yellow);
	}
	
	//////////////////////////////////////////////////////////////////////////////

	private final Class<? extends FmmNode> nodeClass;
	private final String nodeTypeCode;
	private final String className;
	private final int labelTextResourceId;
	private final String labelText;
	private final int labelDrawableResourceId;
	private final Drawable labelDrawable;
	private final HashMap<FmmNodeGlyphType, Integer> nodeGlyphResourceIdMap;
	

	FmmNodeDictionary(
			Class<? extends FmmNode> aNodeClass,
			String aNodeTypeCode,
			int aLabelTextResourceId,
			int aLabelDrawableResourceId,
			HashMap<FmmNodeGlyphType, Integer> aNodeGlyphResourceIdMap) {
		this.nodeClass = aNodeClass;
		this.nodeTypeCode = aNodeTypeCode;
		this.className = aNodeClass.getSimpleName();
		this.labelTextResourceId = aLabelTextResourceId;
		this.labelText = FmmHelper.getContext().getResources().getString(this.labelTextResourceId);
		this.labelDrawableResourceId = aLabelDrawableResourceId;
		this.labelDrawable = FmmHelper.getContext().getResources().getDrawable(this.labelDrawableResourceId);
		this.nodeGlyphResourceIdMap = aNodeGlyphResourceIdMap;
	}

	public String getName() {
		return getClassName();
	}

	public String getClassName() {
		return this.className;
	}
	
	@Override
	public NodeId getNodeId() {
		return null;
	}
	
	@Override
	public String getNodeIdString() {
		return getName();
	}
	
	@Override
	public String getNodeTypeName() {
		return getName();
	}
	
	@Override
	public String toString() {
		return getName();
	}
	
	public Class<? extends FmmNode> getNodeClass() {
		return this.nodeClass;
	}
	
	@Override
	public String getLabelText() {
		return this.labelText;
	}
	
	public int getLabelTextResourceId() {
		return this.labelTextResourceId;
	}

	@Override
	public Drawable getLabelDrawable() {
		return this.labelDrawable;
	}
	
	public int getLabelDrawableResourceId() {
		return this.labelDrawableResourceId;
	}
	
	@Override
	public String getNodeTypeCode() {
		return this.nodeTypeCode;
	}
	
	public boolean isDeKanGlNoun() {
		return FmmDecKanGlDictionary.getInstance().getNounDefinitionForName(getName()) != null;
	}

	public String getViewLabel() {
		return getLabelText();
	}
	
	public HashMap<FmmNodeGlyphType, Integer> getNodeGlyphResourceIdMap() {
		return this.nodeGlyphResourceIdMap;
	}
	
	public int getNodeGlyphResourceId(FmmNodeGlyphType aNodeGlyphType) {
		return this.nodeGlyphResourceIdMap.get(aNodeGlyphType);
	}
	
	public int getUndecoratedGlyphResourceId(FmmNodeGlyphType anFmmNodeGlyphType) {
		Integer theInteger = getNodeGlyphResourceIdMap().get(anFmmNodeGlyphType);
		return theInteger == null
				? R.drawable.icon_undefined
				: theInteger;
	}

	public static String getLabelTextForClass(Class<? extends FmmNode> aNodeClass) {
		FmmNodeDictionary anFmmNodeDictionaryEntry = FmmNodeDictionary.getEntryForClass(aNodeClass);
		return anFmmNodeDictionaryEntry.getLabelText();
	}
	
	@Override
	public String getDataText() {
		return "";
	}
	
	@Override
	public Drawable getDataDrawable() {
		return FmsLibraryApplication.getContext().getResources().getDrawable(getUndecoratedGlyphResourceId(FmmNodeGlyphType.GRAY));
	}

	@Override
	public FmmNodeDictionary getFmmNodeDictionaryEntry() {
		// TODO Auto-generated method stub
		return null;
	}

}
